package message

import (
	"context"
)

// RobotDocsRequest 获取机器人文档请求参数
type RobotDocsRequest struct {
	RobotId  string `json:"robotId" form:"robotId" binding:"required"`  // 机器人标识
	Status   int32  `json:"status" form:"status"`                      // 消息状态筛选（可选）
	Type     int32  `json:"type" form:"type"`                          // 消息类型筛选（可选）
	PageNum  int64  `json:"pageNum" form:"pageNum"`                    // 页码
	PageSize int64  `json:"pageSize" form:"pageSize"`                  // 每页数量
}

// RobotDocsResponse 获取机器人文档响应
type RobotDocsResponse struct {
	Messages []*Message `json:"messages"`           // 文档消息列表
	Total    int64      `json:"total"`              // 总数
	PageNum  int64      `json:"pageNum"`            // 当前页码
	PageSize int64      `json:"pageSize"`           // 每页数量
	Unread   int64      `json:"unread"`             // 未读数量
}

// GetRobotDocs 获取发送给机器人的文档消息
func (dao *MessageDAO) GetRobotDocs(ctx context.Context, req *RobotDocsRequest) ([]*Message, int64, error) {
	var messages []*Message

	// 构建查询条件
	query := dao.engine.Where("receiver = ?", req.RobotId)

	// 添加文件相关筛选条件（只有包含文件的消息）
	query = query.Where("file_url != ''")

	// 可选状态筛选
	if req.Status > 0 {
		query = query.Where("status = ?", req.Status)
	}

	// 可选类型筛选
	if req.Type > 0 {
		query = query.Where("type = ?", req.Type)
	}

	// 按优先级和时间降序排列
	query = query.Desc("priority").Desc("id")

	// 分页查询
	if req.PageNum > 0 && req.PageSize > 0 {
		offset := int((req.PageNum - 1) * req.PageSize)
		query = query.Limit(int(req.PageSize), offset)
	}

	err := query.Find(&messages)
	if err != nil {
		return nil, 0, err
	}

	// 获取总数
	countQuery := dao.engine.Where("receiver = ? AND file_url != ''", req.RobotId)
	if req.Status > 0 {
		countQuery = countQuery.Where("status = ?", req.Status)
	}
	if req.Type > 0 {
		countQuery = countQuery.Where("type = ?", req.Type)
	}

	total, err := countQuery.Count(&Message{})
	if err != nil {
		return nil, 0, err
	}

	return messages, total, nil
}

// GetRobotUnreadCount 获取机器人未读文档数量
func (dao *MessageDAO) GetRobotUnreadCount(ctx context.Context, robotId string) (int64, error) {
	count, err := dao.engine.Where("receiver = ? AND status = 1 AND file_url != ''", robotId).Count(&Message{})
	if err != nil {
		return 0, err
	}
	return count, nil
}

// UpdateMessageStatus 更新消息状态
func (dao *MessageDAO) UpdateMessageStatus(ctx context.Context, messageId int64, status int32) error {
	_, err := dao.engine.ID(messageId).Update(&Message{
		Status: status,
	})
	return err
}

// BatchUpdateMessageStatus 批量更新消息状态
func (dao *MessageDAO) BatchUpdateMessageStatus(ctx context.Context, robotId string, status int32) (int64, error) {
	_, err := dao.engine.Where("receiver = ?", robotId).Update(&Message{
		Status: status,
	})
	if err != nil {
		return 0, err
	}

	// 返回更新的行数
	count, err := dao.engine.Where("receiver = ? AND status = ?", robotId, status).Count(&Message{})
	if err != nil {
		return 0, err
	}
	return count, nil
}